﻿#include<iostream>
#include<queue>
using namespace std;



int main()
{
    priority_queue<int> a;
    priority_queue<int, vector<int>, greater<int> > c;
    priority_queue<string> b;

    for (int i = 0; i < 5; i++)
    {
        a.push(i);
        c.push(i);
    }

    while (!a.empty())
    {
        cout << a.top() << ' ';
        a.pop();
    }

    cout << endl;

    while (!c.empty())
    {
        cout << c.top() << ' ';
        c.pop();
    }
    cout << endl;
    b.push("abc");
    b.push("abcd");
    b.push("cbd");
    while (!b.empty())
    {
        cout << b.top() << ' ';
        b.pop();
    }

    cout << endl;

    return 0;

}


//分别定义名字为A，B的命名空间
//namespace A {
//    int a = 10;
//    void print()
//    {
//        cout << "A:print" << endl;
//    }
//}
//namespace B {
//    int a = 20;
//    void print()
//    {
//        cout << "A:print" << endl;
//    }
//}
//void test1()
//{
//    cout << "A中a = " << A::a << endl;
//    cout << "B中a = " << B::a << endl;
//}
//int main()
//{
//    test1();
//    A::print();
//    B::print();
//}

//#include<iostream>
//using std::cout;
//using std::endl;
//int main()
//{
//	cout<<"HELLO"<<endl;
//	cout<<"WORLD"<<endl;
//}


//void test_namespace()
//{
//	namespace A {
//
//	}
//}

//
//namespace A
//{
//	int a = 0;
//	void A_fun();
//	
//}
//void A::A_fun()
//{
//	cout << " hello " << endl;
//}
//int main()
//{
//	A::A_fun();
//}




//void fun1(int a = 100)
//{
//	cout << "a的值：" << a << endl;
//}

//void fun(int a = 1, int b = 2, int c = 2)
//{
//	cout << a << b << c << endl;
////}
//void fun(int a , int b = 2, int c = 2)
//{
//	cout << a << b << c << endl;
//}
//int main()
//{
//	fun(12);
//	fun(10,20);
//	fun(10, 20, 30);
//	//fun(10, , 30);
//}



//void swap(int* a, int* b)
//{
//	int ret = *a;
//	*a = *b;
//	*b = ret;
//}
//void swap(double* a, double* b)
//{
//	double ret = *a;
//	*a = *b;
//	*b = ret;
//}




//int main()
//{
//	/*int a = 10;
//	int& a_name = a;
//	cout << a << endl;
//	cout << a_name << endl;
//	cout << &a << " " << &a_name << endl;
//	a_name = 100;
//	cout << a_name << endl;*/
//
//	
//	//int a = 10;
//	//// int& ra; // 该条语句编译时会出错
//	//int& ra = a;
//	//int& rra = ra;
//	//printf("%p %p %p\n", &a, &ra, &rra);
//
//
//	//const int a = 10;
//	////int& ra = a; // 该语句编译时会出错，a为常量
//	//const int& ra = a;
//	//// int& b = 10; // 该语句编译时会出错，b为常量
//	//const int& b = 10;
//	//double d = 12.34;
//	////int& rd = d; // 该语句编译时会出错，类型不同
//	//const int& rd = d;
//
//
//
//
//
//	return 0;
//}

//int add(int a, int b)
//{
//	return a + b;
//}
//int main()
//{
//
//	//auto c = 3, d = 4.0;
//
//	//auto b[] = { 4，5，6 };
//	int c = add(10, 20);
//	return 0;
//}




//struct Stack
//{
//	int* p;
//	int capacity;
//	int size;
//};
//void pushStack(int x)
//{
//}
//
//struct Stack
//{
//	int* p;
//	int capacity;
//	int size;
//	void pushStack(int x)
//	{
//	}
//};



//class door {
//	int length;
//	int width;
//
//	void open()
//	{
//		//……
//	}
//	void close()
//	{
//		//……
//	}
//};
//
//class door {
//	int length;
//	int width;
//	void open();
//	void close();
//};
//
//void door::open()
//{
//	//……
//}
//void door::close()
//{
//	//……
//}
//
//
//
//// 类中既有成员变量，又有成员函数
//class A1 {
//public:
//	void f1() {}
//private:
//	int _a;
//	char _b;
//};
//// 类中仅有成员函数
//class A2 {
//public:
//	void f2() {}
//};
//// 类中什么都没有---空类
//class A3
//{};
//
//class Date {
//public:
//	void init(int year, int month, int day)
//	{
//		_year = year;
//		_month = month;
//		_day = day;
//	}
//	void print()
//	{
//		cout << _year << " " << _month << " " << _day << endl;
//	}
//	// 1.无参构造函数
//	Date()
//	{}
//	// 2.带参构造函数
//	Date(const Date& d)
//	{
//		_year = d._year;
//		_month = d._month;
//		_day = d._day;
//	}
//	
//private:
//	int _year;
//	int _month;
//	int _day;
//};
//
//int main()
//{
//
//
//	Date d1; // 调用无参构造函数
//	d1.print();
//
//	Date d2(2015, 1, 1); // 调用带参的构造函数
//
//	// 注意：如果通过无参构造函数创建对象时，对象后面不用跟括号，否则就成了函数声明
//	// 以下代码的函数：声明了d3函数，该函数无参，返回一个日期类型的对象
//	// warning C4930: “Date d3(void)”: 未调用原型函数(是否是有意用变量定义的?)
//	Date d3();
//
//	/*Date d1;
//	d1.init(2023, 3, 5);
//	d1.print();
//	Date d2;
//	d2.init(2023, 3, 6);
//	d2.print();*/
//	return 0;
//}



//class Date
//{
//public:
//	Date(int year, int month, int day)
//
//		: _year(year)
//		, _month(month)
//		, _day(day)
//	{}
//private:
//	int _year;
//	int _month;
//	int _day;
//};



//class A
//{
//public:
//	A(int a)
//		:_a(a)
//	{}
//private:
//	int _a;
//};
//class B
//{
//public:
//	B(int a, int ref)
//		:_aobj(a)
//		, _ref(ref)
//		, _n(10)
//	{}
//private:
//	A _aobj; // 没有默认构造函数  ，如果不指定初始化，系统自动调用默认构造函数将报错：找不到合适的默认构造函数
//	int& _ref; // 引用  因为引用定义时必须初始化
//	const int _n; // const    因为const类的变量定义时必须初始化它是谁的别名
////};
//int main()
//{
//
// 
//}
//
//
//
//class Time
//{
//public:
//	Time(int hour = 0)
//		:_hour(hour)
//	{
//		cout << "Time()" << endl;
//	}
//private:
//	
//		int _hour;
//};
//class Date
//{
//public:
//	Date(int day)
//	{}
//private:
//	int _day;
//	Time _t;
//};
//int main()
//{
//	Date d(1);
//}
//
//class A
//{
//public:
//	A(int a)
//		:_a1(a)
//		, _a2(_a1)
//	{}
//	void Print() {
//		cout << _a1 << " " << _a2 << endl;
//	}
//private:
//	int _a2;
//	int _a1;
//};
//int main() {
//	A aa(1);
//	aa.Print();
//}

//class Date
//{
//public:
//	
//		// 1. 单参构造函数，没有使用explicit修饰，具有类型转换作用
//		// explicit修饰构造函数，禁止类型转换---explicit去掉之后，代码可以通过编译
//	explicit Date(int year)
//		:_year(year)
//	{}
//	
//	
//	// explicit修饰构造函数，禁止类型转换
//	explicit Date(int year, int month = 1, int day = 1)
//	: _year(year)
//	, _month(month)
//	, _day(day)
//	{}
//	
//	Date& operator=(const Date& d)
//	{
//		if (this != &d)
//		{
//			_year = d._year;
//			_month = d._month;
//			_day = d._day;
//		}
//		return *this;
//	}
//private:
//	int _year;
//	int _month;
//	int _day;
//};
//void Test()
//{
//	Date d1(2022);
//	// 用一个整形变量给日期类型对象赋值
//	// 实际编译器背后会用2023构造一个无名对象，最后用无名对象给d1对象进行赋值
//	d1 = 2023;
//	// 将1屏蔽掉，2放开时则编译失败，因为explicit修饰构造函数，禁止了单参构造函数类型转换的作用
//}

//class  A
//{
//public:
//	A() { ++_scount; }
//	A(const A& t) { ++_scount; }
//	~A() { --_scount; }
//	static int GetACount() { return _scount; }
//private:
//	static int _scount;
//};
//int A::_scount = 0;
//void TestA()
//{
//	cout << A::GetACount() << endl;
//	A a1, a2;
//	A a3(a1);
//	cout << A::GetACount() << endl;
//}


//class Date
//{
//public:
//	Date(int year, int month, int day)
//		: _year(year)
//		, _month(month)
//		, _day(day)
//	{}
//	// d1 << cout; -> d1.operator<<(&d1, cout); 不符合常规调用
//	// 因为成员函数第一个参数一定是隐藏的this，所以d1必须放在<<的左侧
//	ostream& operator<<(ostream& _cout)
//	{
//		_cout << _year << "-" << _month << "-" << _day << endl;
//		return _cout;
//	}
//private:
//	int _year;
//	int _month;
//	int _day;
//};


//class Date
//{
//	friend ostream& operator<<(ostream& _cout, const Date& d);
//	friend istream& operator>>(istream& _cin, Date& d);
//public:
//	Date(int year = 1900, int month = 1, int day = 1)
//		: _year(year)
//		, _month(month)
//		, _day(day)
//	{}
//private:
//	int _year;
//	int _month;
//	int _day;
//};
//ostream& operator<<(ostream& _cout, const Date& d)
//{
//	_cout << d._year << "-" << d._month << "-" << d._day;
//	return _cout;
//}
//istream& operator>>(istream& _cin, Date& d)
//{
//	_cin >> d._year;
//	_cin >> d._month;
//	_cin >> d._day;
//	return _cin;
//}
//int main()
//{
//	Date d;
//	cin >> d;
//	cout << d << endl;
//	return 0;
//}


//class Time
//{
//	friend class Date; 
//	// 声明日期类为时间类的友元类，则在日期类中就直接访问Time类中的私有成员变量
//public:
//	Time(int hour = 0, int minute = 0, int second = 0)
//		: _hour(hour)
//		, _minute(minute)
//		, _second(second)
//	{}
//private:
//	int _hour;
//	int _minute;
//	int _second;
//};
//class Date
//{
//public:
//	Date(int year = 1900, int month = 1, int day = 1)
//		: _year(year)
//		, _month(month)
//		, _day(day)
//	{}
//	void SetTimeOfDate(int hour, int minute, int second)
//	{
//		// 直接访问时间类私有的成员变量
//		_t._hour = hour;
//		_t._minute = minute;
//		_t._second = second;
//	}
//private:
//	int _year;
//	int _month;
//	int _day;
//	Time _t;
//};
//
//
//class out
//{
//public:
//	class in
//	{
//		int i;
//		int j;
//	};
//private:
//	int x;
//};
//
//int main()
//{
//	out o;
//	cout << sizeof(o);
//}
//
//




//class A
//{
//public:
//	A(int a = 0)
//		:_a(a)
//	{
//		cout << "A(int a)" << endl;
//	}
//	A(const A& aa)
//		:_a(aa._a)
//	{
//		cout << "A(const A& aa)" << endl;
//	}
//	A& operator=(const A& aa)
//	{
//		cout << "A& operator=(const A& aa)" << endl;
//		if (this != &aa)
//		{
//			_a = aa._a;
//		}
//		return *this;
//	}
//	~A()
//	{
//		cout << "~A()" << endl;
//	}
//private:
//	int _a;
//};
//
//
//
////void f1(A aa)
////{
////}
////A f2()
////{
////	A aa;
////	return aa;
////}
////A f3()
////{
////	return A(1);
////}
//
////int main()
////{
////	// 传值返回
////	A result=f3();  //构造+拷贝构造+拷贝构造->优化为一次直接构造
////
////
////	// 传值传参
////	A a1 = 3;   //构造+拷贝构造->优化为直接构造
////	f1(2);      //构造+拷贝构造->优化为直接构造
////	f1(a1);		//只有一次拷贝传递无优化
////	f1(A(2));   //构造+拷贝构造->优化为直接构造
////
////	
////	A aa1;
////	f1(aa1);
////	cout << endl;
////	
////	cout << endl;
////	// 隐式类型，连续构造+拷贝构造->优化为直接构造
////	f1(1);
////	// 一个表达式中，连续构造+拷贝构造->优化为一个构造
////	f1(A(2));
////	cout << endl;
////	// 一个表达式中，连续拷贝构造+拷贝构造->优化一个拷贝构造
////	A aa2 = f2();
////	cout << endl;
////	// 一个表达式中，连续拷贝构造+赋值重载->无法优化
////	aa1 = f2();
////	cout << endl;
////	return 0;
////}
//
//
//void Test()
//{
//	int* p1 = (int*)malloc(sizeof(int));
//	free(p1);
//	
//	int* p2 = (int*)calloc(4, sizeof(int));
//	int* p3 = (int*)realloc(p2, sizeof(int) * 10);
//	// 这里需要free(p2)吗？
//	//不需要，realloc已经处理过了
//	free(p3);
//}
//
//
//
//int globalVar = 1;
//static int staticGlobalVar = 1;
////void Test()
////{
////	static int staticVar = 1;
////	int localVar = 1;
////	int num1[10] = { 1, 2, 3, 4 };
////	char char2[] = "abcd";
////	const char* pChar3 = "abcd";
////	int* ptr1 = (int*)malloc(sizeof(int) * 4);
////	int* ptr2 = (int*)calloc(4, sizeof(int));
////	int* ptr3 = (int*)realloc(ptr2, sizeof(int) * 4);
////	free(ptr1);
////	free(ptr3);
////}
//
//void Test()
//{
//	//delete与new搭配
//
//	// 1动态申请一个int类型的空间
//	int* ptr4 = new int;
//	delete ptr4;
//
//	// 2动态申请一个int类型的空间并初始化为10
//	int* ptr5 = new int(10);
//	delete ptr5;
//
//
//
//	//delete[]与new[]搭配
//
//	// 1动态申请10个int类型的空间
//	int* ptr6 = new int[10];
//	delete[] ptr6;
//
//	// 2动态申请10个int类型的空间 并初始化为1-10
//	int* ptr7 = new int[10]{ 1,2,3,4,5,6,7,8,9,10 };
//	delete[] ptr7;
//
//}


//class A
//{
//public:
//	A(int a = 0)
//		: _a(a)
//	{
//		cout << "A():" << this << endl;
//	}
//	~A()
//	{
//		cout << "~A():" << this << endl;
//	}
//private:
//	int _a;
//};
//int main()
//{
//	// new/delete 和 malloc/free最大区别是 
//	// new/delete对于【自定义类型】除了开空间还会调用构造函数和析构函数
//	A* p1 = (A*)malloc(sizeof(A));
//	A* p2 = new A(1);
//	free(p1);
//	delete p2;
//
//	A* p5 = (A*)malloc(sizeof(A) * 10);
//	A* p6 = new A[10];
//	free(p5);
//	delete[] p6;
//
//	return 0;
//}

///*
//operator new：该函数实际通过malloc来申请空间，当malloc申请空间成功时直接返回；申请空间
//失败，尝试执行空 间不足应对措施，如果改应对措施用户设置了，则继续申请，否
//则抛异常。
//*/
//void* __CRTDECL operator new(size_t size) _THROW1(_STD bad_alloc)
//{
//	// try to allocate size bytes
//	void* p;
//	while ((p = malloc(size)) == 0)
//		if (_callnewh(size) == 0)
//		{
//			// report no memory
//			// 如果申请内存失败了，这里会抛出bad_alloc 类型异常
//			static const std::bad_alloc nomem;
//			_RAISE(nomem);
//		}
//	return (p);
//}
///*
//operator delete: 该函数最终是通过free来释放空间的
//*/
//void operator delete(void* pUserData)
//{
//	_CrtMemBlockHeader* pHead;
//	RTCCALLBACK(_RTC_Free_hook, (pUserData, 0));
//	if (pUserData == NULL)
//		return;
//	_mlock(_HEAP_LOCK); /* block other threads */
//	__TRY
//		/* get a pointer to memory block header */
//		pHead = pHdr(pUserData);
//	/* verify block type */
//	_ASSERTE(_BLOCK_TYPE_IS_VALID(pHead->nBlockUse));
//	_free_dbg(pUserData, pHead->nBlockUse);
//	__FINALLY
//		_munlock(_HEAP_LOCK); /* release other threads */
//	__END_TRY_FINALLY
//		return;
//}
///*
//free的实现
//*/
//#define free(p) _free_dbg(p, _NORMAL_BLOCK)




//
//
//class A
//{
//public:
//	A(int a = 0)
//		: _a(a)
//	{
//		cout << "A():" << this << endl;
//	}
//	~A()
//	{
//		cout << "~A():" << this << endl;
//	}
//private:
//	int _a;
//};
//// 定位new/replacement new
//int main()
//{
//	// p1现在指向的只不过是与A对象相同大小的一段空间，还不能算是一个对象，因为构造函数没有执行
//	A* p1 = (A*)malloc(sizeof(A));
//	new(p1)A; // 注意：如果A类的构造函数有参数时，此处需要传参
//	p1->~A();
//	free(p1);
//
//	A* p2 = (A*)operator new(sizeof(A));
//	new(p2)A(10);
//	p2->~A();
//	operator delete(p2);
//	return 0;
//}


#include<iostream>
#include<vector>
#include<algorithm>

//using namespace std;
//
//class Solution {
//public:
//	vector<vector<int>> threeSum(vector<int>& nums) {
//		int len = nums.size();
//		sort(nums.begin(), nums.end());
//		vector<vector<int>> result;
//		int ri = 1;
//		for (int i = 0; i < len; i++)
//		{
//			if (i > 0 && nums[i] == nums[i - 1])
//			{
//				continue;
//			}
//			for (int j = i + 1, k = len - 1; j <= k;)
//			{
//				if (nums[k] + nums[j] + nums[i] > 0)
//				{
//					int tmp = nums[k];
//					while (nums[k] == tmp)
//						k--;
//				}
//				else if (nums[k] + nums[j] + nums[i] < 0)
//				{
//					int tmp = nums[j];
//					while (nums[j] == tmp)
//						j++;
//				}
//				else
//				{
//					result.resize(ri);
//					result[ri - 1].resize(3);
//					result[ri - 1][0] = nums[i], result[ri - 1][1] = nums[j], result[ri - 1][2] = nums[k];
//
//					int tmp = nums[j];
//					while (nums[j] == tmp)
//						j++;
//				}
//				cout<<ri<<i<<j<<k<<endl;
//				cout<<i;
//				
//			}
//		}
//		return result;
//
//	}
//};



//模板
//void Swap(int& left, int& right)
//{
//	int temp = left;
//	left = right;
//	right = temp;
//}
//void Swap(double& left, double& right)
//{
//	double temp = left;
//	left = right;
//	right = temp;
//}
//void Swap(char& left, char& right)
//{
//	char temp = left;
//	left = right;
//	right = temp;
//}
//template<class T>
//void Swap(T& left, T& right)
//{
//	T temp = left;
//	left = right;
//	right = temp;
//}
//int main()
//{
//	int a = 10, b = 20;
//	Swap(a, b);
//	double a = 10.0, b = 20.0;
//	Swap(a, b);
//	return 0;
//}

/*
template<typename T1, typename T2,......,typename Tn>
返回值类型 函数名(参数列表){}

template<typename T>
void Swap( T& left, T& right)
{
T temp = left;
left = right;
right = temp;
}*/


//int main()
//{
//	int a1 = 10, a2 = 20;
//	double d1 = 10.0, d2 = 20.0;
//	Add(a1, a2);//编译器推演其实参类型为int
//	Add(d1, d2);//编译器推演其实参类型为double
//	Add(a1, d1);//编译报错，编译器无法确定此处到底该将T确定为int 或者 double类型而报错
//	
//	// 此时有两种处理方式：1. 用户自己来强制转化 2. 使用显式实例化
//	//1.Add(a1,(int)d1);
//	
//	return 0;
//}

//template<class T>
//T Add(const T& left, const T& right)
//{
//	return left + right;
//}
//int main(void)
//{
//	int a = 10;
//	double b = 20.0;
//	// 显式实例化
//	Add<int>(a, b);//此时编译器会进行类型转换
//	return 0;
//}


// 专门处理int的加法函数
//int Add(int left, int right)
//{
//	return left + right;
//}
//
//void Test()
//{
//	Add(1, 2); 
//	Add(1, 2.0); 
//}
//int main()
//{
//	Test();
//	return 0;
//}
//
//
//// 注意：此时Vector不是具体的类，是编译器根据被实例化的类型生成具体类的模具
//template<class T>
//class Vector
//{
//public:
//	Vector(size_t capacity = 10)
//		: _pData(new T[capacity])
//		, _size(0)
//		, _capacity(capacity)
//	{}
//	// 使用析构函数演示：在类中声明，在类外定义。
//	~Vector();
//	void PushBack(const T& data)；
//	void PopBack()；
//	//……
//	size_t Size() { return _size; }
//	T& operator[](size_t pos)
//	{
//		assert(pos < _size);
//		return _pData[pos];
//	}
//private:
//	T* _pData;
//	size_t _size;
//	size_t _capacity;
//};
//// 注意：类模板中函数放在类外进行定义时，需要加模板参数列表
//template <class T>
//Vector<T>::~Vector()
//{
//	if (_pData)
//		delete[] _pData;
//	_size = _capacity = 0;
//}